GridPACK: optimization.hpp Source File

00001 /*
00002  *     Copyright (c) 2013 Battelle Memorial Institute
00003  *     Licensed under modified BSD License. A copy of this license can be found
00004  *     in the LICENSE file in the top level directory of this distribution.
00005  */
00006 // -------------------------------------------------------------
00007 /**
00008  * @file   optimization.hpp
00009  * @author 
00010  * @date   2015-11-20 11:52:32 d3g096
00011  * 
00012  * @brief  
00013  * 
00014  * 
00015  */
00016 // -------------------------------------------------------------
00017 
00018 #ifndef _optimization_hpp_
00019 #define _optimization_hpp_
00020 
00021 #include <vector>
00022 #include <macdecls.h>
00023 #include "boost/smart_ptr/shared_ptr.hpp"
00024 #include "gridpack/timer/coarse_timer.hpp"
00025 #include "gridpack/network/base_network.hpp"
00026 #include "gridpack/component/base_component.hpp"
00027 #include "gridpack/component/optimization_ifc.hpp"
00028 #include <boost/smart_ptr/shared_ptr.hpp>
00029 
00030 #include <ga.h>
00031 
00032 
00033 // Base optimization class that contains functions that are generic to all
00034 // applications.
00035 
00036 namespace gridpack{
00037 namespace optimization{
00038 
00039 template <class _network>
00040 class NetworkOptimizer
00041   : public gridpack::optimization::VariableVisitor
00042 //:
00043 //  public gridpack::parallel::Communicator
00044 {
00045   public:
00046     typedef _network NetworkType;
00047     typedef boost::shared_ptr<NetworkType> NetworkPtr;
00048     typedef boost::shared_ptr<gridpack::optimization::Variable> VarPtr;
00049     typedef boost::shared_ptr<gridpack::optimization::Expression> ExpPtr;
00050     typedef boost::shared_ptr<gridpack::optimization::Constraint> ConstPtr;
00051     ExpPtr objFunc;
00052     std::vector<ConstPtr> locConstraint;
00053     
00054 
00055     int numUnits;
00056     std::vector<int> minUpTime;
00057     std::vector<int> minDownTime;
00058     std::vector<double> minPower;
00059     std::vector<double> demand;
00060     std::vector<double> reserve;
00061     std::vector<double> maxPower;
00062     std::vector<double> costConst;
00063     std::vector<double> costLinear;
00064     std::vector<double> costQuad;
00065     
00066     double *uc_iniLevel;
00067     double *uc_minUpTime ;
00068     double *uc_minDownTime ;
00069     double *uc_minPower ;
00070     double *uc_demand ;
00071     double *uc_maxPower ;
00072     double *uc_costConst ;
00073     double *uc_costLinear ;
00074     double *uc_costQuad ;
00075     double *uc_rampUp ;
00076     double *uc_rampDown ;
00077     double *uc_startUp ;
00078     double *uc_initPeriod ;
00079     double *uc_startCap ;
00080     double *uc_shutCap ;
00081     double *uc_opMaxGen ;
00082     int *busID;
00083     int totalGen;
00084     /**
00085      * Default Constructor
00086      * @param network - network the optimizer works on
00087      */
00088     NetworkOptimizer(NetworkPtr network)
00089       : p_network(network)
00090     { 
00091       p_nBuses = p_network->numBuses();
00092       totalGen = 0;
00093     }
00094 
00095 
00096     /**
00097      * Destructor
00098      */
00099     ~NetworkOptimizer(void)
00100     {}
00101 
00102     /**
00103      * Return a vector of optimization variables associated witht this interface
00104      * @return list of variables
00105      */
00106     std::vector<boost::shared_ptr<gridpack::optimization::Variable> >
00107       getVariables()
00108     {
00109        std::vector<VarPtr> ret;
00110 // to avoid accumulating
00111        VarPtr vptr;
00112        vptr->clear(); 
00113        ret.clear();
00114        double rval;
00115       int grp = p_network->communicator().getGroup();
00116       int nprocs = GA_Pgroup_nnodes(grp);
00117       int me = GA_Pgroup_nodeid(grp);
00118       int loc_totalGen = totalGen;
00119 
00120       std::vector<int> genArr(nprocs);
00121 
00122       for (int p=0; p<nprocs; p++) {
00123         genArr[p] = 0;
00124       }
00125       genArr[me] = p_numUnits*p_numHorizons*5;
00126       GA_Pgroup_igop(grp,&genArr[0], nprocs, "+");
00127       std::vector<int> offset(nprocs);
00128       offset[0] = 0;
00129       for (int p=1; p<nprocs; p++) {
00130         offset[p]= offset[p-1] + genArr[p-1];
00131       }
00132 // 
00133 // power produced
00134        for (int p = 0; p < p_numHorizons; p++) {
00135        int inc = offset[me];
00136          for (int i = 0; i < p_numUnits; i++) {
00137            rval = uc_maxPower[i];
00138            VarPtr vptr (new RealVariable(0.0, 0.0, rval));
00139            vptr->name(boost::str(boost::format("p_u_%d_t_%d")  %inc %p));
00140 
00141            ret.push_back(vptr);
00142            inc++;
00143          }
00144        }
00145 
00146 // reserve required
00147        for (int p = 0; p < p_numHorizons; p++) {
00148        int inc = offset[me]; 
00149          for (int i = 0; i < p_numUnits; i++) {
00150            rval = uc_maxPower[i];
00151            VarPtr vptr (new RealVariable(0.0, 0.0, rval));
00152            vptr->name(boost::str(boost::format("r_u_%d_t_%d") %inc %p));
00153            ret.push_back(vptr);
00154 
00155            inc++;
00156          }
00157        }
00158 // onoff 
00159        for (int p = 0; p < p_numHorizons; p++) {
00160        int inc = offset[me]; 
00161          for (int i = 0; i < p_numUnits; i++) {
00162            VarPtr vptr (new IntegerVariable(0,0,1));
00163            vptr->name(boost::str(boost::format("on_u_%d_t_%d") %inc %p));
00164            ret.push_back(vptr);
00165 
00166            inc++;
00167          }
00168        }
00169 // start up 
00170        for (int p = 0; p < p_numHorizons; p++) {
00171        int inc = offset[me]; 
00172          for (int i = 0; i < p_numUnits; i++) {
00173            VarPtr vptr (new IntegerVariable(0,0,1));
00174            vptr->name(boost::str(boost::format("up_u_%d_t_%d") %inc %p));
00175            ret.push_back(vptr);
00176 
00177            inc++;
00178          }
00179        }
00180 // shut down
00181        for (int p = 0; p < p_numHorizons; p++) {
00182        int inc = offset[me]; 
00183          for (int i = 0; i < p_numUnits; i++) {
00184            VarPtr vptr (new IntegerVariable(0,0,1));
00185            vptr->name(boost::str(boost::format("dn_u_%d_t_%d") %inc %p));
00186            ret.push_back(vptr);
00187 
00188            inc++;
00189          }
00190        }
00191        return ret;
00192     }
00193 
00194     /**
00195      * Return contribution from bus to a global constraint
00196      * @param tag string that can be parsed by bus to determine which constraint
00197      * contribution is being requested
00198      * @return contribution to global constraint. If no contribution, return
00199      * null pointer
00200      */
00201 //    boost::shared_ptr<gridpack::optimization::Expression>
00202     std::vector<ExpPtr>
00203       getGlobalConstraint(const char* tag)
00204     {
00205       std::vector<VarPtr> vlist;
00206       vlist.clear();
00207       vlist = this->getVariables();
00208       int nVar = p_numHorizons*p_numUnits;
00209       int nVarP = nVar;
00210       VarPtr powerProduced;
00211       VarPtr powerReserved;
00212 //  Initial state, treat as constraint
00213       int powerCnt;
00214       int reserveCnt;
00215 // get the list of variables; clear() is required, otherwise, variable number is wrong
00216       std::vector<ExpPtr> ret;
00217       ret.clear();
00218 
00219 // energy balance
00220       for (int p = 1; p < p_numHorizons; p++) {
00221         ExpPtr exprgP;
00222         exprgP.reset();
00223         ExpPtr exprgR;
00224         exprgR.reset();
00225 
00226         for (int i = 0; i < p_numUnits; i++) {
00227            powerCnt = p*p_numUnits + i;
00228            powerProduced = vlist[powerCnt];
00229            reserveCnt = nVarP + powerCnt;
00230            powerReserved = vlist[reserveCnt];
00231            if(!exprgP) {
00232              exprgP = 1*powerProduced;
00233            }else{
00234              exprgP = exprgP + 1*powerProduced;
00235            }
00236 
00237            if(!exprgR) {
00238              exprgR = 1*powerReserved;
00239            }else{
00240              exprgR = exprgR + 1*powerReserved;
00241            }
00242         }
00243         ret.push_back(exprgP);
00244 
00245         ret.push_back(exprgR);
00246 
00247       }
00248       return ret;
00249     }
00250 
00251     /**
00252      * Return a list of local constraints from component
00253      * @return list of constraints
00254      */
00255 //    std::vector<boost::shared_ptr<gridpack::optimization::Constraint> >
00256     std::vector<ConstPtr>
00257       getLocalConstraints()
00258     {
00259       ConstPtr con;
00260       std::vector<VarPtr> vlist;
00261       vlist.clear();
00262       vlist = this->getVariables();
00263       ExpPtr expr;
00264       ExpPtr expr2;
00265       ExpPtr upDnIndicator;
00266       int nVar = p_numHorizons*p_numUnits;
00267       int nVarP = nVar;
00268       int nVarR = nVarP + nVar;
00269       int nIntVcntOnoff = nVarR + nVar;
00270       int nIntVcntStartup = nIntVcntOnoff + nVar;
00271       int nIntVcntShutdown = nIntVcntStartup + nVar;
00272       int powerCntm1 = 0;
00273       int onOffCntm1 = 0; 
00274       int onOffCnttmp = 0;
00275       int upDnPeriod;
00276       VarPtr onOff;
00277       VarPtr onOfftmp;
00278       VarPtr start_Up;
00279       VarPtr shutDown;
00280       VarPtr powerProduced;
00281       VarPtr powerReserved;
00282 //  Initial state, treat as constraint
00283       int onOffCnt;
00284       int start_UpCnt;
00285       int shutDownCnt;
00286       int powerCnt;
00287       int reserveCnt;
00288 // get the list of variables; clear() is required, otherwise, variable number is wrong
00289       std::vector<ConstPtr> ret;
00290       ret.clear();
00291         onOffCnt = nVarR + 1;
00292       for(int i=0; i< p_numUnits; i++) {
00293         onOffCnt = nVarR + i;
00294         con = vlist[onOffCnt] == 1;
00295         ret.push_back(con);
00296 
00297         start_UpCnt = nIntVcntOnoff + i;
00298         con = vlist[start_UpCnt] == 0;
00299         ret.push_back(con);
00300 
00301         shutDownCnt = nIntVcntStartup + i;
00302         con = vlist[shutDownCnt] == 0;
00303         ret.push_back(con);
00304 
00305         powerCnt = i;
00306         con = vlist[powerCnt] == uc_iniLevel[i];
00307         ret.push_back(con);
00308 
00309       }
00310       for (int p = 1; p < p_numHorizons; p++) {
00311         ExpPtr exprgP;
00312         exprgP.reset();
00313         ExpPtr exprgR;
00314         exprgR.reset();
00315         for (int i = 0; i < p_numUnits; i++) {
00316            powerCnt = p*p_numUnits + i;
00317            reserveCnt = nVarP + powerCnt;
00318            onOffCnt = nVarR + powerCnt;
00319            start_UpCnt = nIntVcntOnoff + powerCnt;
00320            shutDownCnt = nIntVcntStartup + powerCnt;
00321          
00322            onOff = vlist[onOffCnt];
00323            start_Up = vlist[start_UpCnt];
00324            shutDown = vlist[shutDownCnt];
00325            powerProduced = vlist[powerCnt];
00326            powerReserved = vlist[reserveCnt];
00327 
00328            expr = powerProduced - 10000*onOff;
00329            con = expr <= 0;
00330            ret.push_back(con);
00331 
00332            expr = powerProduced - uc_minPower[i]*onOff;
00333            con = expr >= 0;
00334            ret.push_back(con);
00335 
00336 // ramp up constraint
00337            powerCntm1 = (p-1)*p_numUnits + i;
00338            expr = powerProduced + powerReserved - vlist[powerCntm1];
00339            con = expr <= uc_rampUp[i];
00340            ret.push_back(con);
00341 
00342 // ramp down constraint
00343            expr = vlist[powerCntm1]-powerProduced;
00344            con = expr <= uc_rampDown[i];
00345            ret.push_back(con);
00346 
00347 // minium up and down time
00348 // on at horizon p
00349            onOffCntm1 = nVarR + (p-1)*p_numUnits + i;;
00350            upDnIndicator = onOff - vlist[onOffCntm1];
00351            if(p == 1) {
00352             int initP = (int)(uc_initPeriod[i]);
00353 //
00354             upDnIndicator = vlist[onOffCntm1] - onOff;
00355             upDnPeriod = std::min(p_numHorizons, (p+(int)(uc_minUpTime[i]+0.5)-initP));
00356             for (int j = p; j < upDnPeriod; j++) {
00357               onOffCnttmp = nVarR + j*p_numUnits + i;;
00358               onOfftmp = vlist[onOffCnttmp];
00359               con = upDnIndicator - 10000*onOfftmp <= 0;
00360               ret.push_back(con);
00361             }
00362            } else{
00363              upDnPeriod = std::min(p_numHorizons, (p+(int)(uc_minUpTime[i]+0.5)));
00364             for (int j = p; j < upDnPeriod; j++) {
00365               onOffCnttmp = nVarR + j*p_numUnits + i;;
00366               onOfftmp = vlist[onOffCnttmp];
00367               con = upDnIndicator - 10000*onOfftmp <= 0;
00368               ret.push_back(con);
00369             }
00370            }
00371 
00372 // start up, previous off
00373            upDnIndicator = onOff - vlist[onOffCntm1];
00374            con = upDnIndicator - 10000*start_Up <= 0;
00375            ret.push_back(con);
00376 
00377 // off at horizon p
00378            upDnIndicator = - 1*vlist[onOffCntm1] + 1*onOff;
00379            upDnPeriod = std::min(p_numHorizons, (p+(int)(uc_minDownTime[i]+0.5)));
00380            for (int j = p; j < upDnPeriod; j++) {
00381              onOffCnttmp = nVarR + j*p_numUnits + i;;
00382              onOfftmp = vlist[onOffCnttmp];
00383              con = upDnIndicator - 10000*onOfftmp <= -1;
00384              ret.push_back(con);
00385            }
00386 // shut down, previous on
00387            upDnIndicator = vlist[onOffCntm1] - onOff;
00388            con = upDnIndicator - 10000*shutDown <= 0;
00389            ret.push_back(con);
00390 
00391 // generation limits
00392 // startup at horizon p
00393            expr = powerProduced + powerReserved
00394            - uc_maxPower[i]*onOff + uc_minPower[i]*onOff
00395                + uc_maxPower[i]*start_Up - uc_startCap[i]*start_Up;
00396            con = expr <= uc_minPower[i];
00397            ret.push_back(con);
00398 
00399 // shutdown at horizon p 
00400            onOffCntm1 = nVarP + powerCntm1;
00401            onOffCnttmp = nVarR + powerCntm1;
00402            expr = vlist[powerCntm1] + vlist[onOffCntm1] -
00403             uc_maxPower[i]*vlist[onOffCnttmp] + uc_minPower[i]*vlist[onOffCnttmp]
00404                 +uc_maxPower[i]*shutDown - uc_shutCap[i]*shutDown;
00405            con = expr  <= uc_minPower[i];
00406            ret.push_back(con);
00407         }
00408 
00409       }
00410       return ret;
00411     }
00412 
00413 
00414     /**
00415      * Return contribution to objective function
00416      * @return expression representing contribution to objective function. If no
00417      * contribution, return null pointer
00418      */
00419 //    boost::shared_ptr<gridpack::optimization::Expression>
00420     ExpPtr
00421       getObjectiveFunction()
00422     {
00423 //  boost::shared_ptr<gridpack::optimization::Expression> ret;
00424       int nVar = p_numHorizons*p_numUnits;
00425       int nRealVcnt = 0;
00426       int nIntVcnt = 2*nVar;
00427       std::vector<VarPtr> vlist;
00428       vlist.clear();
00429       vlist = this->getVariables();
00430       ExpPtr obj;
00431       VarPtr onOff;
00432       VarPtr powerProduced;
00433       VarPtr start_Up;
00434       for (int p = 1; p < p_numHorizons; p++) {
00435         for (int i = 0; i < p_numUnits; i++) {
00436            nRealVcnt = p*p_numUnits + i;
00437            nIntVcnt = nRealVcnt + 2*nVar;
00438            powerProduced = vlist[nRealVcnt];
00439            onOff = vlist[nIntVcnt];
00440            start_Up = vlist[nIntVcnt+nVar];
00441            
00442          if(!obj) {
00443            obj =  uc_costConst[i]*onOff
00444               + uc_startUp[i]*start_Up
00445               + uc_costLinear[i]*powerProduced
00446               + 2.0*uc_costQuad[i]*((powerProduced)^2);
00447          }else
00448          {
00449            obj = obj + uc_costConst[i]*onOff
00450               + uc_startUp[i]*start_Up
00451               + uc_costLinear[i]*powerProduced
00452               + 2.0*uc_costQuad[i]*((powerProduced)^2);
00453          }
00454         }
00455       }
00456       return obj;
00457     }
00458 
00459 
00460     /**
00461      * sum over processes to get global objective function
00462      */
00463     double objectiveFunction(void)
00464     {
00465       int numBus = p_network->numBuses();
00466       int i, j;
00467       int idx1, idx2;
00468       double sum;
00469       sum = 0;
00470 //    loop over buses;
00471       for (i=0; i<numBus; i++) {
00472         if(p_network->getActiveBus(i)) {
00473           int branch_idx, bus1_idx, bus2_idx;
00474           sum += p_network->getBus(i)->objectiveFunction();
00475         }
00476       }
00477       GA_Dgop(&sum,1,"+");
00478       return sum;
00479     }
00480     /**
00481       * solution
00482       */
00483       
00484     /**
00485      * load bus data 
00486      */
00487     void loadBusData(void) 
00488     {
00489       int ivar;
00490       double rvar;
00491       gridpack::component::DataCollection *data;
00492       for (int i=0; i<p_nBuses; i++) {
00493         data = dynamic_cast<gridpack::component::DataCollection*>
00494           (p_network->getBusData(i).get());
00495         data->getValue("GENERATOR_NUMBERS",&numUnits);
00496 // To sum to get total number of generators on the network
00497         for (int idx = 0; idx<numUnits; idx++) {
00498           data->getValue("GENERATOR_MIN_POWER", &rvar, idx);
00499           minPower.push_back(rvar);
00500         }
00501         for (int idx = 0; idx<numUnits; idx++) {
00502           data->getValue("GENERATOR_MAX_POWER", &rvar, idx);
00503           maxPower.push_back(rvar);
00504         }
00505         for (int idx = 0; idx<numUnits; idx++) {
00506           data->getValue("GENERATOR_DEMAND", &rvar, idx);
00507           demand.push_back(rvar);
00508         }
00509         for (int idx = 0; idx<numUnits; idx++) {
00510           data->getValue("GENERATOR_MIN_UPTIME", &ivar, idx);
00511           minUpTime.push_back(ivar);
00512         }
00513         for (int idx = 0; idx<numUnits; idx++) {
00514           data->getValue("GENERATOR_MIN_DNTIME", &ivar, idx);
00515           minDownTime.push_back(ivar);
00516         }
00517         for (int idx = 0; idx<numUnits; idx++) {
00518           data->getValue("GENERATOR_CONST_COST", &rvar, idx);
00519           costConst.push_back(rvar);
00520         }
00521         for (int idx = 0; idx<numUnits; idx++) {
00522           data->getValue("GENERATOR_LINEAR_COST", &rvar, idx);
00523           costLinear.push_back(rvar);
00524         }
00525         for (int idx = 0; idx<numUnits; idx++) {
00526           data->getValue("GENERATOR_QUAD_COST", &rvar, idx);
00527           costQuad.push_back(rvar);
00528         }
00529       } 
00530     }
00531 
00532     /**
00533      * load bus data for expression test 
00534      */
00535     void loadBusData_exp(void) 
00536     {
00537       int ivar;
00538       double rvar;
00539       gridpack::component::DataCollection *data;
00540       for (int i=0; i<p_nBuses; i++) {
00541         data = dynamic_cast<gridpack::component::DataCollection*>
00542           (p_network->getBusData(i).get());
00543         data->getValue("GENERATOR_NUMBERS",&numUnits);
00544 // To sum to get total number of generators on the network
00545         for (int idx = 0; idx<numUnits; idx++) {
00546           data->getValue("GENERATOR_MIN_POWER", &rvar, idx);
00547           minPower.push_back(rvar);
00548         }
00549         for (int idx = 0; idx<numUnits; idx++) {
00550           data->getValue("GENERATOR_MAX_POWER", &rvar, idx);
00551           maxPower.push_back(rvar);
00552         }
00553         for (int idx = 0; idx<numUnits; idx++) {
00554           data->getValue("GENERATOR_MIN_UPTIME", &ivar, idx);
00555           minUpTime.push_back(ivar);
00556         }
00557         for (int idx = 0; idx<numUnits; idx++) {
00558           data->getValue("GENERATOR_MIN_DNTIME", &ivar, idx);
00559           minDownTime.push_back(ivar);
00560         }
00561         for (int idx = 0; idx<numUnits; idx++) {
00562           data->getValue("GENERATOR_CONST_COST", &rvar, idx);
00563           costConst.push_back(rvar);
00564         }
00565         for (int idx = 0; idx<numUnits; idx++) {
00566           data->getValue("GENERATOR_LINEAR_COST", &rvar, idx);
00567           costLinear.push_back(rvar);
00568         }
00569         for (int idx = 0; idx<numUnits; idx++) {
00570           data->getValue("GENERATOR_QUAD_COST", &rvar, idx);
00571           costQuad.push_back(rvar);
00572         }
00573       } 
00574     }
00575     /**
00576       * Get unit commitment parameters
00577       */  
00578     void getUCparam(void) 
00579     {
00580       int ngen;
00581       int gen_id;
00582 //      gridpack::component::DataCollection *data;
00583       double rval;
00584 // create global array to hold data for all generators in the network
00585       int grp = p_network->communicator().getGroup();
00586       int nprocs = GA_Pgroup_nnodes(grp);
00587       int me = GA_Pgroup_nodeid(grp);
00588       for (int i=0; i<p_nBuses; i++){
00589         if(p_network->getActiveBus(i)) {
00590           ngen = p_network->getBus(i)->numGen;
00591           totalGen += ngen;
00592         }
00593       }
00594       int loc_totalGen = totalGen;
00595 //      GA_Igop(&totalGen,1,"+");
00596 
00597       std::vector<int> genArr(nprocs);
00598 
00599       for (int p=0; p<nprocs; p++) {
00600         genArr[p] = 0;
00601       }
00602       genArr[me] = loc_totalGen;
00603       GA_Pgroup_igop(grp,&genArr[0], nprocs, "+");
00604       std::vector<int> offset(nprocs);
00605       offset[0] = 0;
00606       for (int p=1; p<nprocs; p++) {
00607         offset[p]= offset[p-1] + genArr[p-1];
00608       }
00609 
00610       uc_iniLevel = new double[totalGen] ();
00611       uc_minUpTime = new double[totalGen] ();
00612       uc_minDownTime = new double[totalGen] ();
00613       uc_minPower = new double[totalGen] ();
00614       uc_maxPower = new double[totalGen] ();
00615       uc_costConst = new double[totalGen] ();
00616       uc_costLinear = new double[totalGen] ();
00617       uc_costQuad = new double[totalGen] ();
00618       uc_rampUp = new double[totalGen] ();
00619       uc_rampDown = new double[totalGen] ();
00620       uc_startUp = new double[totalGen] ();
00621       uc_initPeriod = new double[totalGen] ();
00622       uc_shutCap = new double[totalGen] ();
00623       uc_opMaxGen = new double[totalGen] ();
00624       uc_startCap = new double[totalGen] ();
00625       busID = new int[totalGen] ();
00626 //      int index = offset[me];
00627       int index = 0;
00628       int busid;
00629       for (int i=0; i<p_nBuses; i++){
00630         if(p_network->getActiveBus(i)) {
00631           ngen = p_network->getBus(i)->numGen;
00632           if(ngen > 0) {
00633             for (int j=0; j<ngen; j++){
00634               p_network->getBusData(i)->getValue("GENERATOR_BUSNUMBER",&busid,j);
00635               busID[index] = busid;        
00636               uc_iniLevel[index] = p_network->getBus(i)->p_iniLevel[j];
00637               uc_minUpTime[index] = p_network->getBus(i)->p_minUpTime[j];
00638               uc_minDownTime[index] = p_network->getBus(i)->p_minDownTime[j];
00639               uc_minPower[index] = p_network->getBus(i)->p_minPower[j];
00640               uc_maxPower[index] = p_network->getBus(i)->p_maxPower[j];
00641               uc_costConst[index] = p_network->getBus(i)->p_costConst[j];
00642               uc_costLinear[index] = p_network->getBus(i)->p_costLinear[j];
00643               uc_costQuad[index] = p_network->getBus(i)->p_costQuad[j];
00644               uc_rampUp[index] = p_network->getBus(i)->p_rampUp[j];
00645               uc_rampDown[index] = p_network->getBus(i)->p_rampDown[j];
00646               uc_startUp[index] = p_network->getBus(i)->p_startUp[j];
00647               uc_shutCap[index] = p_network->getBus(i)->p_shutCap[j];
00648               uc_opMaxGen[index] = p_network->getBus(i)->p_opMaxGen[j];
00649               uc_initPeriod[index] = p_network->getBus(i)->p_initPeriod[j];
00650               uc_startCap[index] = p_network->getBus(i)->p_startCap[j];
00651               index++;
00652             }
00653           }
00654         }
00655       }
00656 #if 0
00657       GA_Pgroup_igop(grp,busID, totalGen, "+");
00658       GA_Pgroup_dgop(grp,uc_iniLevel, totalGen, "+");
00659       GA_Pgroup_dgop(grp,uc_minUpTime, totalGen, "+");
00660       GA_Pgroup_dgop(grp,uc_minDownTime, totalGen, "+");
00661       GA_Pgroup_dgop(grp,uc_minPower, totalGen, "+");
00662       GA_Pgroup_dgop(grp,uc_maxPower, totalGen, "+");
00663       GA_Pgroup_dgop(grp,uc_costConst, totalGen, "+");
00664       GA_Pgroup_dgop(grp,uc_costQuad, totalGen, "+");
00665       GA_Pgroup_dgop(grp,uc_rampUp, totalGen, "+");
00666       GA_Pgroup_dgop(grp,uc_rampDown, totalGen, "+");
00667       GA_Pgroup_dgop(grp,uc_startUp, totalGen, "+");
00668       GA_Pgroup_dgop(grp,uc_initPeriod, totalGen, "+");
00669       GA_Pgroup_dgop(grp,uc_startCap, totalGen, "+");
00670       GA_Pgroup_dgop(grp,uc_shutCap, totalGen, "+");
00671       GA_Pgroup_dgop(grp,uc_costLinear, totalGen, "+");
00672       GA_Pgroup_dgop(grp,uc_opMaxGen, totalGen, "+");
00673 #endif
00674     }
00675 //
00676 // print bus generator solution
00677     void solution(void) 
00678     {
00679       int numBus = p_network->numBuses();
00680       for (int i=0; i<numBus; i++) {
00681         if(p_network->getActiveBus(i)) {
00682           p_network->getBus(i)->solution();
00683         }  
00684       }
00685     }
00686 // Get number of periods and generators
00687     void getLoadsInfo(int numHorizons,double *demand_in, double *reserve_in)
00688     {
00689       int ngen;
00690       p_numUnits = 0;
00691       for (int i=0; i<p_nBuses; i++){
00692         if(p_network->getActiveBus(i)) {
00693           ngen = p_network->getBus(i)->numGen;
00694           p_numUnits += ngen;
00695         }
00696       }
00697       p_numHorizons = numHorizons;
00698 //
00699       demand.clear();
00700       reserve.clear();
00701       for (int i=0; i<numHorizons; i++) {
00702         demand.push_back(demand_in[i]);
00703         reserve.push_back(reserve_in[i]);
00704       }
00705     }
00706 
00707   protected:
00708 
00709     NetworkPtr p_network;
00710 
00711   private:
00712     int  p_nBuses;
00713     int p_numUnits;
00714     int p_numHorizons;
00715 };
00716 
00717 }    // optimization
00718 }    // gridpack
00719 #endif